package com.zhentao.controller;

import com.aliyun.tea.TeaException;
import com.zhentao.config.AliyunConfig;
import com.zhentao.config.MinioConfig;

import com.zhentao.pojo.ProductCollection;
import com.zhentao.pojo.ProductBrowseHistory;
import com.zhentao.service.*;

import com.zhentao.utils.OcrValidationUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhentao.pojo.User;
import com.zhentao.pojo.OrderMain;
import com.zhentao.pojo.Product;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import io.minio.RemoveObjectArgs;
import io.minio.errors.MinioException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.util.StringUtils;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.UUID;
import java.io.InputStream;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import org.springframework.transaction.annotation.Transactional;
import java.util.Objects;

@RestController
@RequestMapping("/users")
//@CrossOrigin(origins = {"http://localhost:5173","http://127.0.0.1:5173"}, allowCredentials = "true")
public class UserInfoController {
    //3.5 个人中心
    //3.5.1 信息管理
    //基本信息:头像、昵称、真实姓名(不可修改)、邮箱
    //联系信息:地区(国家 +地区)、联系方式
    //身份认证:海员认证(上传海员证照片审核)
    //3.5.2 数据管理
    //我的收藏:显示收藏商品列表，支持跳转详情页
    //我的订单:按状态筛选订单，支持搜索和详情查看
    //浏览历史:记录近期浏览的商品信息
    //3.5.3 系统设置
    //账户安全:修改密码、绑定邮箱
    //隐私设置:消息通知开关、个人信息可见范围
    //关于我们:版本信息、用户协议、隐私政策

    private static final Logger logger = LoggerFactory.getLogger(UserInfoController.class);

    @Autowired
    private UserService userService;
    @Autowired
    private OcrService ocrService;
    @Autowired
    private AliyunConfig aliyunConfig;
    @Autowired
    private OrderMainService orderMainService;
    @Autowired
    private ProductCollectionService productCollectionService;
    @Autowired
    private ProductService productService;
    @Autowired
    private ProductBrowseHistoryService productBrowseHistoryService;
    @GetMapping("/findById")
    public User findById(@RequestParam("id") Long id) {
        return userService.getById(id);
    }

    /**
     * 根据用户名获取用户信息
     * @param username 用户名
     * @return 用户信息
     */
    @GetMapping("/findByUsername")
    public ResponseEntity<Map<String, Object>> findByUsername(@RequestParam("username") String username) {
        logger.info("根据用户名获取用户信息，用户名: {}", username);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (!StringUtils.hasText(username)) {
                logger.warn("用户名不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户名不能为空", HttpStatus.BAD_REQUEST);
            }

            // 查询用户信息
            User user = userService.getOne(new QueryWrapper<User>()
                    .eq("username", username)
                    .eq("status", 1)); // 只查询正常状态的用户

            if (user == null) {
                logger.warn("用户不存在，用户名: {}", username);
                // 临时注释掉用户不存在的错误响应
                // return buildErrorResponse(String.valueOf(200), "用户不存在", HttpStatus.NOT_FOUND);

                // 返回一个默认的用户信息，避免前端报错
                response.put("success", true);
                response.put("message", "查询成功");
                Map<String, Object> defaultUser = new HashMap<>();
                defaultUser.put("id", 0);
                defaultUser.put("username", username);
                defaultUser.put("nickname", username);
                defaultUser.put("avatar", "");
                response.put("data", defaultUser);
                return ResponseEntity.ok(response);
            }

            // 构建返回数据（只返回必要的公开信息）
            Map<String, Object> userData = new HashMap<>();
            userData.put("id", user.getId());
            userData.put("username", user.getUsername());
            userData.put("nickname", user.getNickname());
            userData.put("avatar", user.getAvatar());
            userData.put("realName", user.getRealName());

            response.put("success", true);
            response.put("message", "获取用户信息成功");
            response.put("code", "SUCCESS");
            response.put("data", userData);

            logger.info("成功获取用户信息，用户名: {}, 用户ID: {}", username, user.getId());
            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("根据用户名获取用户信息时发生异常，用户名: {}", username, e);
            return buildErrorResponse("INTERNAL_ERROR", "获取用户信息失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 批量根据用户名获取用户信息
     * @param request 包含用户名列表的请求体
     * @return 用户信息列表
     */
    @PostMapping("/findByUsernames")
    public ResponseEntity<List<Map<String, Object>>> findByUsernames(@RequestBody Map<String, Object> request) {
        logger.info("批量根据用户名获取用户信息");

        try {
            // 获取用户名列表
            @SuppressWarnings("unchecked")
            List<String> usernames = (List<String>) request.get("usernames");

            if (usernames == null || usernames.isEmpty()) {
                logger.warn("用户名列表不能为空");
                return ResponseEntity.badRequest().body(new ArrayList<>());
            }

            // 限制批量查询数量，防止性能问题
            if (usernames.size() > 50) {
                logger.warn("批量查询用户名数量过多: {}", usernames.size());
                usernames = usernames.subList(0, 50);
            }

            // 查询用户信息
            List<User> users = userService.list(new QueryWrapper<User>()
                    .in("username", usernames)
                    .eq("status", 1)); // 只查询正常状态的用户

            // 构建返回数据
            List<Map<String, Object>> result = new ArrayList<>();
            for (User user : users) {
                Map<String, Object> userData = new HashMap<>();
                userData.put("id", user.getId());
                userData.put("username", user.getUsername());
                userData.put("nickname", user.getNickname());
                userData.put("avatar", user.getAvatar());
                userData.put("realName", user.getRealName());
                result.add(userData);
            }

            logger.info("成功批量获取用户信息，查询数量: {}, 返回数量: {}", usernames.size(), result.size());
            return ResponseEntity.ok(result);

        } catch (Exception e) {
            logger.error("批量根据用户名获取用户信息时发生异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(new ArrayList<>());
        }
    }
    /**
     * 修改用户信息接口（使用JSON数据）
     * 允许修改：username、nickname、email、phone
     * 只在 Controller 内使用 MyBatis-Plus 的内置更新方法，避免先查再改。
     * @param userInfo 用户信息对象，包含id和需要更新的字段
     * @return 更新结果，true表示成功，false表示失败
     */
    //基本信息:头像、昵称、真实姓名(不可修改)、邮箱
    //联系信息:地区(国家 +地区)、联系方式
    @PostMapping("/updateUsersInfo")
    public boolean updateUsersInfo(@RequestBody User userInfo) { // 使用@RequestBody接收JSON数据，直接使用User实体类

        // 参数基础验证：检查请求对象和用户ID是否为空
        if (userInfo == null || userInfo.getId() == null) { // 检查请求对象和用户ID
            return false; // 请求无效时返回失败
        }

        // 参数有效性检查：如果所有可修改字段都为空，直接返回失败
        if (!StringUtils.hasText(userInfo.getUsername()) // 检查用户名是否为空或空字符串
                && !StringUtils.hasText(userInfo.getNickname()) // 检查昵称是否为空或空字符串
                && !StringUtils.hasText(userInfo.getEmail()) // 检查邮箱是否为空或空字符串
                && !StringUtils.hasText(userInfo.getPhone())) { // 检查联系方式是否为空或空字符串
            return false; // 所有字段都为空时返回失败
        }

        // 创建MyBatis-Plus的Lambda条件更新包装器，用于构建动态更新条件
        LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();

        // 设置更新条件：根据用户ID进行更新
        wrapper.eq(User::getId, userInfo.getId());

        // 动态设置需要更新的字段：只有非空字段才会被更新
        if (StringUtils.hasText(userInfo.getUsername())) { // 如果用户名不为空
            wrapper.set(User::getUsername, userInfo.getUsername()); // 设置更新用户名字段
        }
        if (StringUtils.hasText(userInfo.getNickname())) { // 如果昵称不为空
            wrapper.set(User::getNickname, userInfo.getNickname()); // 设置更新昵称字段
        }
        if (StringUtils.hasText(userInfo.getEmail())) { // 如果邮箱不为空
            wrapper.set(User::getEmail, userInfo.getEmail()); // 设置更新邮箱字段
        }
        if (StringUtils.hasText(userInfo.getPhone())) { // 如果联系方式不为空
            wrapper.set(User::getPhone, userInfo.getPhone()); // 设置更新联系方式字段
        }

        // 自动设置更新时间为当前时间
        wrapper.set(User::getUpdateTime, new Date());

        // 执行更新操作：仅通过 Wrapper set 指定列，无需构造实体对象，提高性能
        return userService.update(null, wrapper); // 调用MyBatis-Plus的更新方法，返回更新结果
    }
    // =========================== 头像管理功能 ===========================

    @Autowired
    private MinioConfig minioConfig;

    // 头像相关配置常量
    private static final String AVATAR_BUCKET = "avatar";
    private static final long MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB
    private static final String[] ALLOWED_TYPES = {"image/jpeg", "image/jpg", "image/png", "image/gif"};

    /**
     * 创建MinIO客户端
     */
    private MinioClient createMinioClient() {
        return MinioClient.builder()
                .endpoint(minioConfig.getEndpoint())
                .credentials(minioConfig.getAccessKey(), minioConfig.getSecretKey())
                .build();
    }

    /**
     * 上传用户头像
     * @param userId 用户ID
     * @param file 头像文件
     * @return 上传结果
     */
    @PostMapping("/avatar/upload")
    public ResponseEntity<Map<String, Object>> uploadAvatar(
            @RequestParam("userId") Long userId,
            @RequestParam("file") MultipartFile file) {

        logger.info("上传用户头像，用户ID: {}, 文件名: {}, 文件大小: {} bytes",
                userId, file.getOriginalFilename(), file.getSize());

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null) {
                logger.warn("用户ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID不能为空", HttpStatus.BAD_REQUEST);
            }

            if (file == null || file.isEmpty()) {
                logger.warn("头像文件不能为空");
                return buildErrorResponse("INVALID_FILE", "请选择头像文件", HttpStatus.BAD_REQUEST);
            }

            // 验证用户是否存在
            User user = userService.getById(userId);
            if (user == null) {
                logger.warn("用户不存在，用户ID: {}", userId);
                return buildErrorResponse("USER_NOT_FOUND", "用户不存在", HttpStatus.NOT_FOUND);
            }

            // 文件大小验证
            if (file.getSize() > MAX_FILE_SIZE) {
                logger.warn("文件过大，大小: {} bytes", file.getSize());
                return buildErrorResponse("FILE_TOO_LARGE", "文件大小不能超过5MB", HttpStatus.BAD_REQUEST);
            }

            // 文件类型验证
            String contentType = file.getContentType();
            boolean isValidType = false;
            for (String allowedType : ALLOWED_TYPES) {
                if (allowedType.equals(contentType)) {
                    isValidType = true;
                    break;
                }
            }

            if (!isValidType) {
                logger.warn("不支持的文件类型: {}", contentType);
                return buildErrorResponse("INVALID_FILE_TYPE", "只支持JPG、PNG、GIF格式的图片", HttpStatus.BAD_REQUEST);
            }

            // 生成唯一文件名
            String originalFilename = file.getOriginalFilename();
            logger.info("原始文件名: {}", originalFilename);

            String fileExtension = "";
            if (originalFilename != null && originalFilename.contains(".")) {
                fileExtension = originalFilename.substring(originalFilename.lastIndexOf("."));
            }
            String objectName = "user_" + userId + "_" + UUID.randomUUID().toString() + fileExtension;
            logger.info("生成的对象名: {}", objectName);
            logger.info("文件内容类型: {}, 文件大小: {} bytes", contentType, file.getSize());

            // 创建MinIO客户端并上传文件
            MinioClient minioClient = createMinioClient();

            try (InputStream inputStream = file.getInputStream()) {
                logger.info("开始上传文件到MinIO，桶名: {}, 对象名: {}", AVATAR_BUCKET, objectName);

                minioClient.putObject(
                    PutObjectArgs.builder()
                        .bucket(AVATAR_BUCKET)
                        .object(objectName)
                        .stream(inputStream, file.getSize(), -1)
                        .contentType(contentType)
                        .build()
                );

                logger.info("文件上传到MinIO成功，对象名: {}", objectName);
                logger.info("MinIO存储路径: {}/{}/{}", minioConfig.getEndpoint(), AVATAR_BUCKET, objectName);

                // 构建头像访问URL
                String avatarUrl = minioConfig.getEndpoint() + "/" + AVATAR_BUCKET + "/" + objectName;

                // 删除旧头像（如果存在）
                if (StringUtils.hasText(user.getAvatar()) && !"identity_verified".equals(user.getAvatar())) {
                    try {
                        String oldObjectName = extractObjectNameFromUrl(user.getAvatar());
                        if (oldObjectName != null) {
                            minioClient.removeObject(
                                RemoveObjectArgs.builder()
                                    .bucket(AVATAR_BUCKET)
                                    .object(oldObjectName)
                                    .build()
                            );
                            logger.info("删除旧头像成功: {}", oldObjectName);
                        }
                    } catch (Exception e) {
                        logger.warn("删除旧头像失败: {}", e.getMessage());
                    }
                }

                // 更新用户头像URL到数据库
                LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.eq(User::getId, userId)
                        .set(User::getAvatar, avatarUrl)
                        .set(User::getUpdateTime, new Date());

                boolean updateResult = userService.update(null, updateWrapper);

                if (updateResult) {
                    // 构建响应数据
                    Map<String, Object> data = new HashMap<>();
                    data.put("userId", userId);
                    data.put("avatarUrl", avatarUrl);
                    data.put("objectName", objectName);
                    data.put("uploadTime", new Date());
                    data.put("fileSize", file.getSize());
                    data.put("contentType", contentType);

                    response.put("success", true);
                    response.put("message", "头像上传成功");
                    response.put("code", "SUCCESS");
                    response.put("data", data);

                    logger.info("头像上传成功，用户ID: {}, 头像URL: {}", userId, avatarUrl);
                    return ResponseEntity.ok(response);
                } else {
                    logger.error("更新用户头像URL失败，用户ID: {}", userId);
                    return buildErrorResponse("UPDATE_FAILED", "头像上传成功但更新用户信息失败", HttpStatus.INTERNAL_SERVER_ERROR);
                }

            }

        } catch (MinioException e) {
            logger.error("MinIO操作异常，用户ID: {}", userId, e);
            return buildErrorResponse("MINIO_ERROR", "文件存储服务异常: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        } catch (InvalidKeyException | NoSuchAlgorithmException e) {
            logger.error("MinIO认证异常，用户ID: {}", userId, e);
            return buildErrorResponse("AUTH_ERROR", "存储服务认证失败", HttpStatus.INTERNAL_SERVER_ERROR);
        } catch (IOException e) {
            logger.error("文件读取异常，用户ID: {}", userId, e);
            return buildErrorResponse("FILE_READ_ERROR", "文件读取失败", HttpStatus.INTERNAL_SERVER_ERROR);
        } catch (Exception e) {
            logger.error("头像上传时发生异常，用户ID: {}", userId, e);
            return buildErrorResponse("INTERNAL_ERROR", "头像上传失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 获取用户头像信息
     * @param userId 用户ID
     * @return 头像信息
     */
    @GetMapping("/avatar/info")
    public ResponseEntity<Map<String, Object>> getAvatarInfo(@RequestParam("userId") Long userId) {

        logger.info("获取用户头像信息，用户ID: {}", userId);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null) {
                logger.warn("用户ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 查询用户信息
            User user = userService.getById(userId);
            if (user == null) {
                logger.warn("用户不存在，用户ID: {}", userId);
                return buildErrorResponse("USER_NOT_FOUND", "用户不存在", HttpStatus.NOT_FOUND);
            }

            // 构建头像信息
            Map<String, Object> data = new HashMap<>();
            data.put("userId", userId);
            data.put("avatarUrl", user.getAvatar());
            data.put("hasAvatar", StringUtils.hasText(user.getAvatar()) && !"identity_verified".equals(user.getAvatar()));
            data.put("updateTime", user.getUpdateTime());

            response.put("success", true);
            response.put("message", "获取头像信息成功");
            response.put("code", "SUCCESS");
            response.put("data", data);

            logger.info("成功获取用户头像信息，用户ID: {}, 是否有头像: {}", userId, data.get("hasAvatar"));
            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("获取用户头像信息时发生异常，用户ID: {}", userId, e);
            return buildErrorResponse("INTERNAL_ERROR", "获取头像信息失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 从URL中提取对象名称
     * @param url MinIO文件URL
     * @return 对象名称
     */
    private String extractObjectNameFromUrl(String url) {
        if (!StringUtils.hasText(url)) {
            return null;
        }

        try {
            // URL格式: http://8.145.55.161:19000/avatars/user_123_uuid.jpg
            String bucketPrefix = "/" + AVATAR_BUCKET + "/";
            int index = url.indexOf(bucketPrefix);
            if (index != -1) {
                return url.substring(index + bucketPrefix.length());
            }
        } catch (Exception e) {
            logger.warn("解析头像URL失败: {}", url, e);
        }

        return null;
    }

    //身份认证:海员认证(上传海员证照片审核)

    // =========================== OCR身份证识别功能 ===========================

    /**
     * 身份证照片识别接口
     * 支持身份证正面和反面识别，用于用户身份认证
     *
     * @param file 身份证照片文件
     * @param side 身份证面（face：正面，back：反面）
     * @return 识别结果
     */
    @PostMapping("/recognize-idcard")
    public ResponseEntity<Map<String, Object>> recognizeIdcard(
            @RequestParam("file") MultipartFile file,
            @RequestParam(value = "side", defaultValue = "face") String side) {

        logger.info("收到身份证OCR识别请求，文件: {}, 面: {}", file.getOriginalFilename(), side);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            String validationError = OcrValidationUtil.validateRequest(file, side);
            if (validationError != null) {
                logger.warn("参数验证失败: {}", validationError);
                return buildErrorResponse("INVALID_PARAMETER", validationError, HttpStatus.BAD_REQUEST);
            }

            // 执行OCR识别
            Map<String, Object> result = ocrService.recognizeIdcard(file, side);

            // 返回成功结果
            response.put("success", true);
            response.put("message", "身份证识别成功");
            response.put("code", "SUCCESS");
            response.put("data", result);

            logger.info("身份证OCR识别成功，文件: {}", file.getOriginalFilename());
            return ResponseEntity.ok(response);

        } catch (TeaException e) {
            logger.error("阿里云OCR API调用异常: {}", e.getMessage(), e);
            return buildErrorResponse("OCR_API_ERROR", "身份证识别服务异常: " + e.getMessage(),
                    HttpStatus.INTERNAL_SERVER_ERROR);

        } catch (Exception e) {
            logger.error("身份证OCR识别发生异常", e);
            return buildErrorResponse("INTERNAL_ERROR", "身份证识别服务内部错误",
                    HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 身份证照片识别接口（Base64方式）
     * 支持身份证正面和反面识别，通过POST方式接收base64编码的图片数据
     *
     * @param requestBody 包含imageData和side的请求体
     * @return 识别结果
     */
    @PostMapping("/recognize-idcard-base64")
    public ResponseEntity<Map<String, Object>> recognizeIdcardBase64(
            @RequestBody Map<String, String> requestBody) {

        String imageData = requestBody.get("imageData");
        String side = requestBody.getOrDefault("side", "face");

        logger.info("收到身份证OCR识别请求（Base64方式），数据长度: {}, 面: {}",
                   imageData != null ? imageData.length() : 0, side);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (imageData == null || imageData.trim().isEmpty()) {
                logger.warn("图片数据为空");
                return buildErrorResponse("INVALID_PARAMETER", "图片数据不能为空", HttpStatus.BAD_REQUEST);
            }

            if (!"face".equals(side) && !"back".equals(side)) {
                logger.warn("身份证面参数错误: {}", side);
                return buildErrorResponse("INVALID_PARAMETER", "身份证面参数错误，请指定face（正面）或back（反面）", HttpStatus.BAD_REQUEST);
            }

            // 将base64转换为MultipartFile
            MultipartFile file = convertBase64ToMultipartFile(imageData);

            // 执行OCR识别
            Map<String, Object> result = ocrService.recognizeIdcard(file, side);

            // 返回成功结果
            response.put("success", true);
            response.put("message", "身份证识别成功");
            response.put("code", "SUCCESS");
            response.put("data", result);

            logger.info("身份证OCR识别成功（Base64方式），数据长度: {}", imageData.length());
            return ResponseEntity.ok(response);

        } catch (TeaException e) {
            logger.error("阿里云OCR API调用异常（Base64方式）: {}", e.getMessage(), e);
            return buildErrorResponse("OCR_API_ERROR", "身份证识别服务异常: " + e.getMessage(),
                    HttpStatus.INTERNAL_SERVER_ERROR);

        } catch (Exception e) {
            logger.error("身份证OCR识别失败（Base64方式）", e);
            return buildErrorResponse("OCR_ERROR", "身份证识别失败: " + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * OCR服务健康检查接口
     *
     * @return 服务状态
     */
    @GetMapping("/ocr/health")
    public ResponseEntity<Map<String, Object>> ocrHealthCheck() {
        Map<String, Object> response = new HashMap<>();
        response.put("service", "OCR Identity Card Recognition");
        response.put("status", "healthy");
        response.put("timestamp", System.currentTimeMillis());
        response.put("endpoint", aliyunConfig.getOcr().getEndpoint());
        response.put("hasAccessKey", aliyunConfig.getOcr().getAccessKeyId() != null &&
                !aliyunConfig.getOcr().getAccessKeyId().trim().isEmpty());

        return ResponseEntity.ok(response);
    }

    /**
     * 构建错误响应
     */
    private ResponseEntity<Map<String, Object>> buildErrorResponse(String code, String message, HttpStatus status) {
        Map<String, Object> response = new HashMap<>();
        response.put("success", false);
        response.put("code", code);
        response.put("message", message);
        return ResponseEntity.status(status).body(response);
    }

    // =========================== 我的订单管理功能 ===========================

    /**
     * 获取用户订单列表（支持状态筛选、搜索、分页）
     * @param userId 用户ID
     * @param status 订单状态（可选：0=待付款 1=配货中 2=送货中 3=已完成 4=异常）
     * @param orderNo 订单号（可选，用于搜索）
     * @param page 页码（默认1）
     * @param size 每页大小（默认10）
     * @return 订单列表分页结果
     */
    @GetMapping("/orders")
    public ResponseEntity<Map<String, Object>> getUserOrders(
            @RequestParam("userId") Long userId,
            @RequestParam(value = "status", required = false) Integer status,
            @RequestParam(value = "orderNo", required = false) String orderNo,
            @RequestParam(value = "page", defaultValue = "1") Integer page,
            @RequestParam(value = "size", defaultValue = "10") Integer size) {

        logger.info("获取用户订单列表，用户ID: {}, 状态: {}, 订单号: {}, 页码: {}, 每页大小: {}",
                userId, status, orderNo, page, size);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null) {
                logger.warn("用户ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 创建分页对象
            Page<OrderMain> pageInfo = new Page<>(page, size);

            // 创建查询条件构造器
            LambdaQueryWrapper<OrderMain> queryWrapper = new LambdaQueryWrapper<>();

            // 必须条件：用户ID
            queryWrapper.eq(OrderMain::getUserId, userId);

            // 可选条件：订单状态筛选
            if (status != null) {
                queryWrapper.eq(OrderMain::getOrderStatus, status);
            }

            // 可选条件：订单号搜索（模糊查询）
            if (StringUtils.hasText(orderNo)) {
                queryWrapper.like(OrderMain::getOrderNo, orderNo);
            }

            // 排序：按创建时间倒序
            queryWrapper.orderByDesc(OrderMain::getCreateTime);

            // 执行分页查询
            Page<OrderMain> result = orderMainService.page(pageInfo, queryWrapper);

            // 构建响应数据
            Map<String, Object> data = new HashMap<>();
            data.put("orders", result.getRecords()); // 订单列表
            data.put("total", result.getTotal()); // 总记录数
            data.put("pages", result.getPages()); // 总页数
            data.put("current", result.getCurrent()); // 当前页
            data.put("size", result.getSize()); // 每页大小

            response.put("success", true);
            response.put("message", "获取订单列表成功");
            response.put("code", "SUCCESS");
            response.put("data", data);

            logger.info("成功获取用户订单列表，用户ID: {}, 返回 {} 条记录", userId, result.getRecords().size());
            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("获取用户订单列表时发生异常，用户ID: {}", userId, e);
            return buildErrorResponse("INTERNAL_ERROR", "获取订单列表失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 根据ID获取订单详情
     * @param orderId 订单ID
     * @param userId 用户ID（用于权限验证，确保用户只能查看自己的订单）
     * @return 订单详情
     */
    @GetMapping("/order/detail")
    public ResponseEntity<Map<String, Object>> getOrderDetail(
            @RequestParam("orderId") Long orderId,
            @RequestParam("userId") Long userId) {

        logger.info("获取订单详情，订单ID: {}, 用户ID: {}", orderId, userId);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (orderId == null || userId == null) {
                logger.warn("订单ID和用户ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "订单ID和用户ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 查询订单（同时验证订单是否属于该用户）
            LambdaQueryWrapper<OrderMain> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(OrderMain::getOrderId, orderId)
                    .eq(OrderMain::getUserId, userId);

            OrderMain order = orderMainService.getOne(queryWrapper);

            if (order == null) {
                logger.warn("订单不存在或无权限访问，订单ID: {}, 用户ID: {}", orderId, userId);
                return buildErrorResponse("ORDER_NOT_FOUND", "订单不存在或无权限访问", HttpStatus.NOT_FOUND);
            }

            response.put("success", true);
            response.put("message", "获取订单详情成功");
            response.put("code", "SUCCESS");
            response.put("data", order);

            logger.info("成功获取订单详情，订单ID: {}, 订单号: {}", orderId, order.getOrderNo());
            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("获取订单详情时发生异常，订单ID: {}, 用户ID: {}", orderId, userId, e);
            return buildErrorResponse("INTERNAL_ERROR", "获取订单详情失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 获取订单状态统计（按状态分组统计数量）
     * @param userId 用户ID
     * @return 各状态订单数量统计
     */
    @GetMapping("/orders/statistics")
    public ResponseEntity<Map<String, Object>> getOrderStatistics(@RequestParam("userId") Long userId) {

        logger.info("获取用户订单状态统计，用户ID: {}", userId);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null) {
                logger.warn("用户ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 基础查询条件
            LambdaQueryWrapper<OrderMain> baseWrapper = new LambdaQueryWrapper<>();
            baseWrapper.eq(OrderMain::getUserId, userId);

            // 统计各状态订单数量
            Map<String, Long> statistics = new HashMap<>();

            // 待付款订单数量（状态=1）
            LambdaQueryWrapper<OrderMain> pendingWrapper = baseWrapper.clone().eq(OrderMain::getOrderStatus, 1);
            long pendingCount = orderMainService.count(pendingWrapper);
            statistics.put("pending", pendingCount);

            // 配货中订单数量（状态=2）
            LambdaQueryWrapper<OrderMain> processingWrapper = baseWrapper.clone().eq(OrderMain::getOrderStatus, 2);
            long processingCount = orderMainService.count(processingWrapper);
            statistics.put("processing", processingCount);

            // 送货中订单数量（状态=3）
            LambdaQueryWrapper<OrderMain> shippingWrapper = baseWrapper.clone().eq(OrderMain::getOrderStatus, 3);
            long shippingCount = orderMainService.count(shippingWrapper);
            statistics.put("shipping", shippingCount);

            // 已完成订单数量（状态=4）
            LambdaQueryWrapper<OrderMain> completedWrapper = baseWrapper.clone().eq(OrderMain::getOrderStatus, 4);
            long completedCount = orderMainService.count(completedWrapper);
            statistics.put("completed", completedCount);

            // 已取消订单数量（状态=5）
            LambdaQueryWrapper<OrderMain> cancelledWrapper = baseWrapper.clone().eq(OrderMain::getOrderStatus, 5);
            long cancelledCount = orderMainService.count(cancelledWrapper);
            statistics.put("cancelled", cancelledCount);

            // 总订单数量
            long totalCount = orderMainService.count(baseWrapper);
            statistics.put("total", totalCount);

            response.put("success", true);
            response.put("message", "获取订单统计成功");
            response.put("code", "SUCCESS");
            response.put("data", statistics);

            logger.info("成功获取用户订单统计，用户ID: {}, 总订单数: {}", userId, totalCount);
            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("获取订单统计时发生异常，用户ID: {}", userId, e);
            return buildErrorResponse("INTERNAL_ERROR", "获取订单统计失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    // =========================== 我的收藏管理功能 ===========================

    /**
     * 获取用户收藏商品列表（支持分页）
     * @param userId 用户ID
     * @param page 页码（默认1）
     * @param size 每页大小（默认10）
     * @return 收藏商品列表分页结果
     */
    @GetMapping("/favorites")
    public ResponseEntity<Map<String, Object>> getUserFavorites(
            @RequestParam("userId") Long userId,
            @RequestParam(value = "page", defaultValue = "1") Integer page,
            @RequestParam(value = "size", defaultValue = "10") Integer size) {

        logger.info("获取用户收藏列表，用户ID: {}, 页码: {}, 每页大小: {}", userId, page, size);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null) {
                logger.warn("用户ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 创建分页对象
            Page<ProductCollection> pageInfo = new Page<>(page, size);

            // 创建查询条件构造器
            LambdaQueryWrapper<ProductCollection> queryWrapper = new LambdaQueryWrapper<>();

            // 查询条件：用户ID
            queryWrapper.eq(ProductCollection::getUserId, userId);

            // 排序：按收藏时间倒序
            queryWrapper.orderByDesc(ProductCollection::getCollectionTime);

            // 执行分页查询收藏记录
            Page<ProductCollection> favoritesResult = productCollectionService.page(pageInfo, queryWrapper);

            // 获取收藏的商品详情列表
            List<Map<String, Object>> favoriteProducts = new ArrayList<>();

            for (ProductCollection favorite : favoritesResult.getRecords()) {
                // 查询商品详情
                Product product = productService.getById(favorite.getProductId());

                if (product != null) {
                    // 构建收藏商品信息
                    Map<String, Object> favoriteProduct = new HashMap<>();
                    favoriteProduct.put("favoriteId", favorite.getCollectionId()); // 收藏记录ID
                    favoriteProduct.put("productId", product.getProductId()); // 商品ID
                    favoriteProduct.put("productName", product.getName()); // 商品名称
                    favoriteProduct.put("coverImage", ""); // 商品封面图（新表结构中需要另外关联）
                    favoriteProduct.put("description", ""); // 商品描述（新表结构中需要另外关联）
                    favoriteProduct.put("status", product.getStatus()); // 商品状态
                    favoriteProduct.put("categoryId", product.getLevel2Id()); // 分类ID
                    favoriteProduct.put("supplierId", product.getSupplierId()); // 供应商ID
                    favoriteProduct.put("favoriteTime", favorite.getCollectionTime()); // 收藏时间
                    favoriteProduct.put("price", product.getPrice()); // 商品价格
                    favoriteProduct.put("originalPrice", product.getOriginalPrice()); // 商品原价

                    favoriteProducts.add(favoriteProduct);
                }
            }

            // 构建响应数据
            Map<String, Object> data = new HashMap<>();
            data.put("favorites", favoriteProducts); // 收藏商品列表
            data.put("total", favoritesResult.getTotal()); // 总记录数
            data.put("pages", favoritesResult.getPages()); // 总页数
            data.put("current", favoritesResult.getCurrent()); // 当前页
            data.put("size", favoritesResult.getSize()); // 每页大小

            response.put("success", true);
            response.put("message", "获取收藏列表成功");
            response.put("code", "SUCCESS");
            response.put("data", data);

            logger.info("成功获取用户收藏列表，用户ID: {}, 返回 {} 条记录", userId, favoriteProducts.size());
            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("获取用户收藏列表时发生异常，用户ID: {}", userId, e);
            return buildErrorResponse("INTERNAL_ERROR", "获取收藏列表失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 添加商品到收藏
     * @param userId 用户ID
     * @param productId 商品ID
     * @return 添加结果
     */
    @PostMapping("/favorites/add")
    public ResponseEntity<Map<String, Object>> addToFavorites(
            @RequestParam("userId") Long userId,
            @RequestParam("productId") Long productId) {

        logger.info("添加商品到收藏，用户ID: {}, 商品ID: {}", userId, productId);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null || productId == null) {
                logger.warn("用户ID和商品ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID和商品ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 检查商品是否存在
            Product product = productService.getById(productId);
            if (product == null) {
                logger.warn("商品不存在，商品ID: {}", productId);
                return buildErrorResponse("PRODUCT_NOT_FOUND", "商品不存在", HttpStatus.NOT_FOUND);
            }

            // 检查是否已经收藏
            LambdaQueryWrapper<ProductCollection> checkWrapper = new LambdaQueryWrapper<>();
            checkWrapper.eq(ProductCollection::getUserId, userId)
                    .eq(ProductCollection::getProductId, productId);

            ProductCollection existingFavorite = productCollectionService.getOne(checkWrapper);
            if (existingFavorite != null) {
                logger.warn("商品已经在收藏列表中，用户ID: {}, 商品ID: {}", userId, productId);
                return buildErrorResponse("ALREADY_FAVORITED", "商品已经在收藏列表中", HttpStatus.CONFLICT);
            }

            // 创建收藏记录
            ProductCollection favorite = new ProductCollection();
            favorite.setUserId(userId); // 设置用户ID
            favorite.setProductId(productId); // 设置商品ID
            favorite.setCollectionTime(new Date()); // 设置收藏时间

            // 保存收藏记录
            boolean saveResult = productCollectionService.save(favorite);

            if (saveResult) {
                response.put("success", true);
                response.put("message", "添加收藏成功");
                response.put("code", "SUCCESS");
                response.put("data", favorite);

                logger.info("成功添加商品到收藏，用户ID: {}, 商品ID: {}, 收藏ID: {}", userId, productId, favorite.getCollectionId());
                return ResponseEntity.ok(response);
            } else {
                logger.error("保存收藏记录失败，用户ID: {}, 商品ID: {}", userId, productId);
                return buildErrorResponse("SAVE_FAILED", "添加收藏失败", HttpStatus.INTERNAL_SERVER_ERROR);
            }

        } catch (Exception e) {
            logger.error("添加商品到收藏时发生异常，用户ID: {}, 商品ID: {}", userId, productId, e);
            return buildErrorResponse("INTERNAL_ERROR", "添加收藏失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 取消收藏商品
     * @param userId 用户ID
     * @param productId 商品ID
     * @return 取消结果
     */
    @DeleteMapping("/favorites/remove")
    public ResponseEntity<Map<String, Object>> removeFromFavorites(
            @RequestParam("userId") Long userId,
            @RequestParam("productId") Long productId) {

        logger.info("取消收藏商品，用户ID: {}, 商品ID: {}", userId, productId);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null || productId == null) {
                logger.warn("用户ID和商品ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID和商品ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 创建删除条件
            LambdaQueryWrapper<ProductCollection> deleteWrapper = new LambdaQueryWrapper<>();
            deleteWrapper.eq(ProductCollection::getUserId, userId)
                    .eq(ProductCollection::getProductId, productId);

            // 执行删除操作
            boolean removeResult = productCollectionService.remove(deleteWrapper);

            if (removeResult) {
                response.put("success", true);
                response.put("message", "取消收藏成功");
                response.put("code", "SUCCESS");

                logger.info("成功取消收藏商品，用户ID: {}, 商品ID: {}", userId, productId);
                return ResponseEntity.ok(response);
            } else {
                logger.warn("收藏记录不存在，用户ID: {}, 商品ID: {}", userId, productId);
                return buildErrorResponse("FAVORITE_NOT_FOUND", "收藏记录不存在", HttpStatus.NOT_FOUND);
            }

        } catch (Exception e) {
            logger.error("取消收藏商品时发生异常，用户ID: {}, 商品ID: {}", userId, productId, e);
            return buildErrorResponse("INTERNAL_ERROR", "取消收藏失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 检查商品是否已收藏
     * @param userId 用户ID
     * @param productId 商品ID
     * @return 收藏状态
     */
    @GetMapping("/favorites/check")
    public ResponseEntity<Map<String, Object>> checkFavoriteStatus(
            @RequestParam("userId") Long userId,
            @RequestParam("productId") Long productId) {

        logger.info("检查商品收藏状态，用户ID: {}, 商品ID: {}", userId, productId);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null || productId == null) {
                logger.warn("用户ID和商品ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID和商品ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 查询收藏记录
            LambdaQueryWrapper<ProductCollection> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProductCollection::getUserId, userId)
                    .eq(ProductCollection::getProductId, productId);

            ProductCollection favorite = productCollectionService.getOne(queryWrapper);

            // 构建响应数据
            Map<String, Object> data = new HashMap<>();
            data.put("isFavorited", favorite != null); // 是否已收藏
            if (favorite != null) {
                data.put("favoriteId", favorite.getCollectionId()); // 收藏记录ID
                data.put("favoriteTime", favorite.getCollectionTime()); // 收藏时间
            }

            response.put("success", true);
            response.put("message", "获取收藏状态成功");
            response.put("code", "SUCCESS");
            response.put("data", data);

            logger.info("成功获取商品收藏状态，用户ID: {}, 商品ID: {}, 是否收藏: {}", userId, productId, favorite != null);
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            logger.error("检查商品收藏状态时发生异常，用户ID: {}, 商品ID: {}", userId, productId, e);
            return buildErrorResponse("INTERNAL_ERROR", "获取收藏状态失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }

    }
    // =========================== 实名认证管理功能 ===========================

    /**
     * 提交实名认证信息
     * @param userId 用户ID
     * @param realName 真实姓名
     * @param idNumber 身份证号
     * @param phone 联系电话
     * @param frontImageInfo 正面识别信息（JSON格式）
     * @param backImageInfo 反面识别信息（JSON格式）
     * @return 提交结果
     */
    @PostMapping("/identity/submit")
    @Transactional
    public ResponseEntity<Map<String, Object>> submitIdentityVerification(
            @RequestParam("userId") Long userId,
            @RequestParam("realName") String realName,
            @RequestParam("idNumber") String idNumber,
            @RequestParam("phone") String phone,
            @RequestParam(value = "frontImageInfo", required = false) String frontImageInfo,
            @RequestParam(value = "backImageInfo", required = false) String backImageInfo) {

        logger.info("📝 提交实名认证信息，用户ID: {}, 真实姓名: {}, 身份证号: {}", userId, realName,
                idNumber != null && idNumber.length() > 6 ? idNumber.substring(0, 6) + "***" : "未提供");

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null || !StringUtils.hasText(realName) ||
                !StringUtils.hasText(idNumber) || !StringUtils.hasText(phone)) {
                logger.warn("❌ 实名认证参数不完整");
                return buildErrorResponse("INVALID_PARAMETER", "请完善认证信息", HttpStatus.BAD_REQUEST);
            }

            // 验证身份证号格式（简单验证）
            if (idNumber.length() != 18) {
                logger.warn("❌ 身份证号格式不正确，长度: {}", idNumber.length());
                return buildErrorResponse("INVALID_ID_NUMBER", "身份证号格式不正确", HttpStatus.BAD_REQUEST);
            }

            // 检查用户是否存在
            User user = userService.getById(userId);
            if (user == null) {
                logger.warn("❌ 用户不存在，用户ID: {}", userId);
                // 临时注释掉用户不存在的错误响应
                // return buildErrorResponse("USER_NOT_FOUND", "用户不存在", HttpStatus.NOT_FOUND);

                // 返回默认认证状态，避免前端报错
                Map<String, Object> data = new HashMap<>();
                data.put("userId", userId);
                data.put("realName", "");
                data.put("status", "not_verified");
                data.put("message", "尚未进行实名认证");

                response.put("success", true);
                response.put("message", "查询成功");
                response.put("data", data);
                return ResponseEntity.ok(response);
            }

            logger.info("👤 查询到用户信息: ID={}, username={}, 当前real_name={}, 当前avatar={}",
                    user.getId(), user.getUsername(), user.getRealName(), user.getAvatar());

            // 记录当前头像，后续用于校验是否被误改
            final String originalAvatar = user.getAvatar();

            // 检查是否已经认证过（放宽检查条件，允许重新认证）
            if (StringUtils.hasText(user.getRealName()) && !"null".equals(user.getRealName())) {
                logger.warn("⚠️ 用户已完成实名认证，用户ID: {}, 当前姓名: {}", userId, user.getRealName());
                // 注释掉冲突返回，允许重新认证
                logger.info("🔄 允许重新认证，继续处理...");
            }

            // 更新用户实名信息（严禁改动 avatar）
            logger.info("🔄 开始更新用户实名信息...");
            LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(User::getId, userId)
                    .set(User::getRealName, realName)
                    .set(User::getPhone, phone)
                    .set(User::getUpdateTime, new Date());

            // 如果有认证图片信息，可单独持久化到认证表；此处不要写入头像字段，避免覆盖用户头像
            if (StringUtils.hasText(frontImageInfo)) {
                // NOTE: 不再占用 avatar 字段存储认证标记，防止用户头像被覆盖
                logger.info("📷 收到认证正面识别信息，已忽略对 avatar 的写入");
            }

            boolean updateResult = userService.update(null, updateWrapper);
            logger.info("💾 数据库更新结果: {}", updateResult);

            if (updateResult) {
                // 验证更新是否成功，并做 avatar 防护
                User updatedUser = userService.getById(userId);
                String currentAvatar = updatedUser != null ? updatedUser.getAvatar() : null;
                if (!Objects.equals(currentAvatar, originalAvatar)) {
                    logger.warn("⚠️ 检测到 avatar 在实名认证流程中被修改，执行回滚。before={}, after={}", originalAvatar, currentAvatar);
                    LambdaUpdateWrapper<User> restore = new LambdaUpdateWrapper<>();
                    restore.eq(User::getId, userId).set(User::getAvatar, originalAvatar);
                    userService.update(null, restore);
                    // 再读一遍做确认
                    updatedUser = userService.getById(userId);
                    logger.info("✅ 已恢复 avatar 字段为原值: {}", updatedUser != null ? updatedUser.getAvatar() : null);
                }

                logger.info("✅ 更新后用户信息: ID={}, real_name={}, phone={}, avatar={}",
                        updatedUser != null ? updatedUser.getId() : userId,
                        updatedUser != null ? updatedUser.getRealName() : realName,
                        updatedUser != null ? updatedUser.getPhone() : phone,
                        updatedUser != null ? updatedUser.getAvatar() : originalAvatar);

                // 构建响应数据
                Map<String, Object> data = new HashMap<>();
                data.put("userId", userId);
                data.put("realName", realName);
                data.put("status", "approved"); // 直接设置为已认证状态
                data.put("submitTime", new Date());
                data.put("verifiedAt", new Date());

                // 记录认证详细信息日志
                if (StringUtils.hasText(frontImageInfo) || StringUtils.hasText(backImageInfo)) {
                    logger.info("📋 收到身份证识别信息，用户ID: {}", userId);
                    if (StringUtils.hasText(frontImageInfo)) {
                        logger.debug("🆔 正面识别信息长度: {}", frontImageInfo.length());
                    }
                    if (StringUtils.hasText(backImageInfo)) {
                        logger.debug("🆔 反面识别信息长度: {}", backImageInfo.length());
                    }
                }

                response.put("success", true);
                response.put("message", "实名认证信息提交成功");
                response.put("code", 200);
                response.put("data", data);

                logger.info("🎉 成功提交实名认证信息，用户ID: {}, 真实姓名: {}", userId, realName);
                return ResponseEntity.ok(response);
            } else {
                logger.error("❌ 更新用户实名信息失败，用户ID: {}", userId);
                return buildErrorResponse("UPDATE_FAILED", "提交认证信息失败", HttpStatus.INTERNAL_SERVER_ERROR);
            }

        } catch (Exception e) {
            logger.error("💥 提交实名认证信息时发生异常，用户ID: {}", userId, e);
            return buildErrorResponse("INTERNAL_ERROR", "提交认证信息失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 获取实名认证状态
     * @param userId 用户ID
     * @return 认证状态信息
     */
    @GetMapping("/identity/status")
    public ResponseEntity<Map<String, Object>> getIdentityStatus(@RequestParam("userId") Long userId) {

        logger.info("获取实名认证状态，用户ID: {}", userId);

        Map<String, Object> response = new HashMap<>();

        try {
            // 参数验证
            if (userId == null) {
                logger.warn("用户ID不能为空");
                return buildErrorResponse("INVALID_PARAMETER", "用户ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 查询用户信息
            User user = userService.getById(userId);
            if (user == null) {
                logger.warn("用户不存在，用户ID: {}", userId);
                // 临时注释掉用户不存在的错误响应
                // return buildErrorResponse("USER_NOT_FOUND", "用户不存在", HttpStatus.NOT_FOUND);

                // 返回默认认证状态，避免前端报错
                Map<String, Object> data = new HashMap<>();
                data.put("userId", userId);
                data.put("realName", "");
                data.put("status", "not_verified");
                data.put("message", "尚未进行实名认证");

                response.put("success", true);
                response.put("message", "查询成功");
                response.put("data", data);
                return ResponseEntity.ok(response);
            }

            // 构建认证状态信息
            Map<String, Object> data = new HashMap<>();
            data.put("userId", userId);
            data.put("realName", user.getRealName());

            // 判断认证状态
            String status;
            String message;
            if (!StringUtils.hasText(user.getRealName())) {
                status = "not_verified";
                message = "尚未进行实名认证";
            } else {
                status = "approved"; // 简化处理，有realName就认为已认证
                message = "实名认证已通过";
            }

            data.put("status", status);
            data.put("message", message);
            data.put("verifiedAt", user.getUpdateTime());

            response.put("success", true);
            response.put("message", "获取认证状态成功");
            response.put("code", 200);
            response.put("data", data);

            logger.info("成功获取实名认证状态，用户ID: {}, 状态: {}", userId, status);
            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("获取实名认证状态时发生异常，用户ID: {}", userId, e);
            return buildErrorResponse("INTERNAL_ERROR", "获取认证状态失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    // =========================== 浏览历史管理功能 ===========================

    /**
     * 记录用户浏览商品
     * 简化版本：每次浏览都插入新记录，使用新的表结构
     */
    @PostMapping("/browsing/record")
    public ResponseEntity<Map<String, Object>> recordBrowsing(
            @RequestParam("userId") Long userId,
            @RequestParam("productId") Long productId) {
        logger.info("记录浏览历史，请求 userId: {}, productId: {}", userId, productId);
        try {
            if (userId == null || productId == null) {
                return buildErrorResponse("INVALID_PARAMETER", "用户ID和商品ID不能为空", HttpStatus.BAD_REQUEST);
            }

            // 校验商品存在
            Product product = productService.getById(productId);
            if (product == null) {
                return buildErrorResponse("PRODUCT_NOT_FOUND", "商品不存在", HttpStatus.NOT_FOUND);
            }

            // 直接插入新浏览记录（简化版本）
            ProductBrowseHistory record = new ProductBrowseHistory();
            record.setUserId(userId);
            record.setProductId(productId);
            record.setBrowseTime(new Date());

            boolean ok = productBrowseHistoryService.save(record);

            if (!ok) {
                return buildErrorResponse("SAVE_FAILED", "记录浏览历史失败", HttpStatus.INTERNAL_SERVER_ERROR);
            }
            Map<String, Object> resp = new HashMap<>();
            resp.put("success", true);
            resp.put("code", "SUCCESS");
            resp.put("message", "记录成功");
            return ResponseEntity.ok(resp);
        } catch (Exception e) {
            logger.error("记录浏览历史异常", e);
            return buildErrorResponse("INTERNAL_ERROR", "记录浏览历史失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 分页获取用户最近浏览的商品
     */
    @GetMapping("/browsing/list")
    public ResponseEntity<Map<String, Object>> listBrowsing(
            @RequestParam("userId") Long userId,
            @RequestParam(value = "page", defaultValue = "1") Integer page,
            @RequestParam(value = "size", defaultValue = "10") Integer size) {
        logger.info("获取浏览历史列表 userId: {}, page: {}, size: {}", userId, page, size);
        try {
            if (userId == null) {
                return buildErrorResponse("INVALID_PARAMETER", "用户ID不能为空", HttpStatus.BAD_REQUEST);
            }
            Page<ProductBrowseHistory> pageInfo = new Page<>(page, size);
            LambdaQueryWrapper<ProductBrowseHistory> qw = new LambdaQueryWrapper<>();
            qw.eq(ProductBrowseHistory::getUserId, userId)
                    .orderByDesc(ProductBrowseHistory::getBrowseTime);
            Page<ProductBrowseHistory> result = productBrowseHistoryService.page(pageInfo, qw);

            // 组装带商品信息的数据
            List<Map<String, Object>> items = new ArrayList<>();
            for (ProductBrowseHistory h : result.getRecords()) {
                Map<String, Object> item = new HashMap<>();
                item.put("historyId", h.getHistoryId());
                item.put("productId", h.getProductId());
                item.put("browseTime", h.getBrowseTime());
                // 可选：附带商品概要
                Product p = productService.getById(h.getProductId());
                if (p != null) {
                    item.put("productName", p.getName());
                    item.put("coverImage", ""); // 新表结构中需要另外关联
                    item.put("description", ""); // 新表结构中需要另外关联
                    item.put("status", p.getStatus());
                    item.put("price", p.getPrice());
                    item.put("originalPrice", p.getOriginalPrice());
                }
                items.add(item);
            }

            Map<String, Object> data = new HashMap<>();
            data.put("histories", items);
            data.put("total", result.getTotal());
            data.put("pages", result.getPages());
            data.put("current", result.getCurrent());
            data.put("size", result.getSize());

            Map<String, Object> resp = new HashMap<>();
            resp.put("success", true);
            resp.put("code", "SUCCESS");
            resp.put("message", "获取成功");
            resp.put("data", data);
            return ResponseEntity.ok(resp);
        } catch (Exception e) {
            logger.error("获取浏览历史列表异常", e);
            return buildErrorResponse("INTERNAL_ERROR", "获取浏览历史失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 删除单条浏览历史
     */
    @DeleteMapping("/browsing/remove")
    public ResponseEntity<Map<String, Object>> removeBrowsing(
            @RequestParam("userId") Long userId,
            @RequestParam("historyId") Long historyId) {
        logger.info("删除浏览历史 userId: {}, historyId: {}", userId, historyId);
        try {
            if (userId == null || historyId == null) {
                return buildErrorResponse("INVALID_PARAMETER", "用户ID和historyId不能为空", HttpStatus.BAD_REQUEST);
            }
            LambdaQueryWrapper<ProductBrowseHistory> qw = new LambdaQueryWrapper<>();
            qw.eq(ProductBrowseHistory::getHistoryId, historyId)
                    .eq(ProductBrowseHistory::getUserId, userId);
            boolean ok = productBrowseHistoryService.remove(qw);
            if (!ok) {
                return buildErrorResponse("NOT_FOUND", "记录不存在", HttpStatus.NOT_FOUND);
            }
            Map<String, Object> resp = new HashMap<>();
            resp.put("success", true);
            resp.put("code", "SUCCESS");
            resp.put("message", "删除成功");
            return ResponseEntity.ok(resp);
        } catch (Exception e) {
            logger.error("删除浏览历史异常", e);
            return buildErrorResponse("INTERNAL_ERROR", "删除失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 清空用户浏览历史
     */
    @DeleteMapping("/browsing/clear")
    public ResponseEntity<Map<String, Object>> clearBrowsing(@RequestParam("userId") Long userId) {
        logger.info("清空浏览历史 userId: {}", userId);
        try {
            if (userId == null) {
                return buildErrorResponse("INVALID_PARAMETER", "用户ID不能为空", HttpStatus.BAD_REQUEST);
            }
            LambdaQueryWrapper<ProductBrowseHistory> qw = new LambdaQueryWrapper<>();
            qw.eq(ProductBrowseHistory::getUserId, userId);
            boolean ok = productBrowseHistoryService.remove(qw);
            if (!ok) {
                return buildErrorResponse("NOTHING_TO_CLEAR", "没有可清空的记录", HttpStatus.NOT_FOUND);
            }
            Map<String, Object> resp = new HashMap<>();
            resp.put("success", true);
            resp.put("code", "SUCCESS");
            resp.put("message", "清空成功");
            return ResponseEntity.ok(resp);
        } catch (Exception e) {
            logger.error("清空浏览历史异常", e);
            return buildErrorResponse("INTERNAL_ERROR", "清空失败", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * 将Base64字符串转换为MultipartFile
     * @param base64Data Base64编码的图片数据
     * @return MultipartFile对象
     */
    private MultipartFile convertBase64ToMultipartFile(String base64Data) {
        try {
            // 解码Base64数据
            byte[] decodedBytes = java.util.Base64.getDecoder().decode(base64Data);

            // 创建自定义的MultipartFile实现
            return new Base64MultipartFile(decodedBytes, "idcard.jpg", "image/jpeg");

        } catch (Exception e) {
            logger.error("Base64转换失败", e);
            throw new RuntimeException("图片数据格式错误", e);
        }
    }

    /**
     * 自定义MultipartFile实现类，用于包装Base64解码后的字节数据
     */
    private static class Base64MultipartFile implements MultipartFile {
        private final byte[] content;
        private final String name;
        private final String contentType;

        public Base64MultipartFile(byte[] content, String name, String contentType) {
            this.content = content;
            this.name = name;
            this.contentType = contentType;
        }

        @Override
        public String getName() {
            return "file";
        }

        @Override
        public String getOriginalFilename() {
            return name;
        }

        @Override
        public String getContentType() {
            return contentType;
        }

        @Override
        public boolean isEmpty() {
            return content == null || content.length == 0;
        }

        @Override
        public long getSize() {
            return content.length;
        }

        @Override
        public byte[] getBytes() {
            return content;
        }

        @Override
        public java.io.InputStream getInputStream() {
            return new java.io.ByteArrayInputStream(content);
        }

        @Override
        public void transferTo(java.io.File dest) throws java.io.IOException, IllegalStateException {
            try (java.io.FileOutputStream fos = new java.io.FileOutputStream(dest)) {
                fos.write(content);
            }
        }
    }

}
